home *** CD-ROM | disk | FTP | other *** search
/ PCGUIA 127 / PC Guia 127.iso / Software / Produtividade / OpenOffice.org 2.0.1 / openofficeorg4.cab / test_parser.py < prev    next >
Text File  |  2005-11-19  |  12KB  |  385 lines
  1. import parser
  2. import unittest
  3. from test import test_support
  4.  
  5. #
  6. #  First, we test that we can generate trees from valid source fragments,
  7. #  and that these valid trees are indeed allowed by the tree-loading side
  8. #  of the parser module.
  9. #
  10.  
  11. class RoundtripLegalSyntaxTestCase(unittest.TestCase):
  12.  
  13.     def roundtrip(self, f, s):
  14.         st1 = f(s)
  15.         t = st1.totuple()
  16.         try:
  17.             st2 = parser.sequence2st(t)
  18.         except parser.ParserError:
  19.             self.fail("could not roundtrip %r" % s)
  20.  
  21.         self.assertEquals(t, st2.totuple(),
  22.                           "could not re-generate syntax tree")
  23.  
  24.     def check_expr(self, s):
  25.         self.roundtrip(parser.expr, s)
  26.  
  27.     def check_suite(self, s):
  28.         self.roundtrip(parser.suite, s)
  29.  
  30.     def test_yield_statement(self):
  31.         self.check_suite("def f(): yield 1")
  32.         self.check_suite("def f(): return; yield 1")
  33.         self.check_suite("def f(): yield 1; return")
  34.         self.check_suite("def f():\n"
  35.                          "    for x in range(30):\n"
  36.                          "        yield x\n")
  37.  
  38.     def test_expressions(self):
  39.         self.check_expr("foo(1)")
  40.         self.check_expr("[1, 2, 3]")
  41.         self.check_expr("[x**3 for x in range(20)]")
  42.         self.check_expr("[x**3 for x in range(20) if x % 3]")
  43.         self.check_expr("foo(*args)")
  44.         self.check_expr("foo(*args, **kw)")
  45.         self.check_expr("foo(**kw)")
  46.         self.check_expr("foo(key=value)")
  47.         self.check_expr("foo(key=value, *args)")
  48.         self.check_expr("foo(key=value, *args, **kw)")
  49.         self.check_expr("foo(key=value, **kw)")
  50.         self.check_expr("foo(a, b, c, *args)")
  51.         self.check_expr("foo(a, b, c, *args, **kw)")
  52.         self.check_expr("foo(a, b, c, **kw)")
  53.         self.check_expr("foo + bar")
  54.         self.check_expr("foo - bar")
  55.         self.check_expr("foo * bar")
  56.         self.check_expr("foo / bar")
  57.         self.check_expr("foo // bar")
  58.         self.check_expr("lambda: 0")
  59.         self.check_expr("lambda x: 0")
  60.         self.check_expr("lambda *y: 0")
  61.         self.check_expr("lambda *y, **z: 0")
  62.         self.check_expr("lambda **z: 0")
  63.         self.check_expr("lambda x, y: 0")
  64.         self.check_expr("lambda foo=bar: 0")
  65.         self.check_expr("lambda foo=bar, spaz=nifty+spit: 0")
  66.         self.check_expr("lambda foo=bar, **z: 0")
  67.         self.check_expr("lambda foo=bar, blaz=blat+2, **z: 0")
  68.         self.check_expr("lambda foo=bar, blaz=blat+2, *y, **z: 0")
  69.         self.check_expr("lambda x, *y, **z: 0")
  70.  
  71.     def test_print(self):
  72.         self.check_suite("print")
  73.         self.check_suite("print 1")
  74.         self.check_suite("print 1,")
  75.         self.check_suite("print >>fp")
  76.         self.check_suite("print >>fp, 1")
  77.         self.check_suite("print >>fp, 1,")
  78.  
  79.     def test_simple_expression(self):
  80.         # expr_stmt
  81.         self.check_suite("a")
  82.  
  83.     def test_simple_assignments(self):
  84.         self.check_suite("a = b")
  85.         self.check_suite("a = b = c = d = e")
  86.  
  87.     def test_simple_augmented_assignments(self):
  88.         self.check_suite("a += b")
  89.         self.check_suite("a -= b")
  90.         self.check_suite("a *= b")
  91.         self.check_suite("a /= b")
  92.         self.check_suite("a //= b")
  93.         self.check_suite("a %= b")
  94.         self.check_suite("a &= b")
  95.         self.check_suite("a |= b")
  96.         self.check_suite("a ^= b")
  97.         self.check_suite("a <<= b")
  98.         self.check_suite("a >>= b")
  99.         self.check_suite("a **= b")
  100.  
  101.     def test_function_defs(self):
  102.         self.check_suite("def f(): pass")
  103.         self.check_suite("def f(*args): pass")
  104.         self.check_suite("def f(*args, **kw): pass")
  105.         self.check_suite("def f(**kw): pass")
  106.         self.check_suite("def f(foo=bar): pass")
  107.         self.check_suite("def f(foo=bar, *args): pass")
  108.         self.check_suite("def f(foo=bar, *args, **kw): pass")
  109.         self.check_suite("def f(foo=bar, **kw): pass")
  110.  
  111.         self.check_suite("def f(a, b): pass")
  112.         self.check_suite("def f(a, b, *args): pass")
  113.         self.check_suite("def f(a, b, *args, **kw): pass")
  114.         self.check_suite("def f(a, b, **kw): pass")
  115.         self.check_suite("def f(a, b, foo=bar): pass")
  116.         self.check_suite("def f(a, b, foo=bar, *args): pass")
  117.         self.check_suite("def f(a, b, foo=bar, *args, **kw): pass")
  118.         self.check_suite("def f(a, b, foo=bar, **kw): pass")
  119.  
  120.     def test_import_from_statement(self):
  121.         self.check_suite("from sys.path import *")
  122.         self.check_suite("from sys.path import dirname")
  123.         self.check_suite("from sys.path import dirname as my_dirname")
  124.         self.check_suite("from sys.path import dirname, basename")
  125.         self.check_suite(
  126.             "from sys.path import dirname as my_dirname, basename")
  127.         self.check_suite(
  128.             "from sys.path import dirname, basename as my_basename")
  129.  
  130.     def test_basic_import_statement(self):
  131.         self.check_suite("import sys")
  132.         self.check_suite("import sys as system")
  133.         self.check_suite("import sys, math")
  134.         self.check_suite("import sys as system, math")
  135.         self.check_suite("import sys, math as my_math")
  136.  
  137.     def test_pep263(self):
  138.         self.check_suite("# -*- coding: iso-8859-1 -*-\n"
  139.                          "pass\n")
  140.  
  141.     def test_assert(self):
  142.         self.check_suite("assert alo < ahi and blo < bhi\n")
  143.  
  144. #
  145. #  Second, we take *invalid* trees and make sure we get ParserError
  146. #  rejections for them.
  147. #
  148.  
  149. class IllegalSyntaxTestCase(unittest.TestCase):
  150.  
  151.     def check_bad_tree(self, tree, label):
  152.         try:
  153.             parser.sequence2st(tree)
  154.         except parser.ParserError:
  155.             pass
  156.         else:
  157.             self.fail("did not detect invalid tree for %r" % label)
  158.  
  159.     def test_junk(self):
  160.         # not even remotely valid:
  161.         self.check_bad_tree((1, 2, 3), "<junk>")
  162.  
  163.     def test_illegal_yield_1(self):
  164.         # Illegal yield statement: def f(): return 1; yield 1
  165.         tree = \
  166.         (257,
  167.          (264,
  168.           (285,
  169.            (259,
  170.             (1, 'def'),
  171.             (1, 'f'),
  172.             (260, (7, '('), (8, ')')),
  173.             (11, ':'),
  174.             (291,
  175.              (4, ''),
  176.              (5, ''),
  177.              (264,
  178.               (265,
  179.                (266,
  180.                 (272,
  181.                  (275,
  182.                   (1, 'return'),
  183.                   (313,
  184.                    (292,
  185.                     (293,
  186.                      (294,
  187.                       (295,
  188.                        (297,
  189.                         (298,
  190.                          (299,
  191.                           (300,
  192.                            (301,
  193.                             (302, (303, (304, (305, (2, '1')))))))))))))))))),
  194.                (264,
  195.                 (265,
  196.                  (266,
  197.                   (272,
  198.                    (276,
  199.                     (1, 'yield'),
  200.                     (313,
  201.                      (292,
  202.                       (293,
  203.                        (294,
  204.                         (295,
  205.                          (297,
  206.                           (298,
  207.                            (299,
  208.                             (300,
  209.                              (301,
  210.                               (302,
  211.                                (303, (304, (305, (2, '1')))))))))))))))))),
  212.                  (4, ''))),
  213.                (6, ''))))),
  214.            (4, ''),
  215.            (0, ''))))
  216.         self.check_bad_tree(tree, "def f():\n  return 1\n  yield 1")
  217.  
  218.     def test_illegal_yield_2(self):
  219.         # Illegal return in generator: def f(): return 1; yield 1
  220.         tree = \
  221.         (257,
  222.          (264,
  223.           (265,
  224.            (266,
  225.             (278,
  226.              (1, 'from'),
  227.              (281, (1, '__future__')),
  228.              (1, 'import'),
  229.              (279, (1, 'generators')))),
  230.            (4, ''))),
  231.          (264,
  232.           (285,
  233.            (259,
  234.             (1, 'def'),
  235.             (1, 'f'),
  236.             (260, (7, '('), (8, ')')),
  237.             (11, ':'),
  238.             (291,
  239.              (4, ''),
  240.              (5, ''),
  241.              (264,
  242.               (265,
  243.                (266,
  244.                 (272,
  245.                  (275,
  246.                   (1, 'return'),
  247.                   (313,
  248.                    (292,
  249.                     (293,
  250.                      (294,
  251.                       (295,
  252.                        (297,
  253.                         (298,
  254.                          (299,
  255.                           (300,
  256.                            (301,
  257.                             (302, (303, (304, (305, (2, '1')))))))))))))))))),
  258.                (264,
  259.                 (265,
  260.                  (266,
  261.                   (272,
  262.                    (276,
  263.                     (1, 'yield'),
  264.                     (313,
  265.                      (292,
  266.                       (293,
  267.                        (294,
  268.                         (295,
  269.                          (297,
  270.                           (298,
  271.                            (299,
  272.                             (300,
  273.                              (301,
  274.                               (302,
  275.                                (303, (304, (305, (2, '1')))))))))))))))))),
  276.                  (4, ''))),
  277.                (6, ''))))),
  278.            (4, ''),
  279.            (0, ''))))
  280.         self.check_bad_tree(tree, "def f():\n  return 1\n  yield 1")
  281.  
  282.     def test_print_chevron_comma(self):
  283.         # Illegal input: print >>fp,
  284.         tree = \
  285.         (257,
  286.          (264,
  287.           (265,
  288.            (266,
  289.             (268,
  290.              (1, 'print'),
  291.              (35, '>>'),
  292.              (290,
  293.               (291,
  294.                (292,
  295.                 (293,
  296.                  (295,
  297.                   (296,
  298.                    (297,
  299.                     (298, (299, (300, (301, (302, (303, (1, 'fp')))))))))))))),
  300.              (12, ','))),
  301.            (4, ''))),
  302.          (0, ''))
  303.         self.check_bad_tree(tree, "print >>fp,")
  304.  
  305.     def test_a_comma_comma_c(self):
  306.         # Illegal input: a,,c
  307.         tree = \
  308.         (258,
  309.          (311,
  310.           (290,
  311.            (291,
  312.             (292,
  313.              (293,
  314.               (295,
  315.                (296,
  316.                 (297,
  317.                  (298, (299, (300, (301, (302, (303, (1, 'a')))))))))))))),
  318.           (12, ','),
  319.           (12, ','),
  320.           (290,
  321.            (291,
  322.             (292,
  323.              (293,
  324.               (295,
  325.                (296,
  326.                 (297,
  327.                  (298, (299, (300, (301, (302, (303, (1, 'c'))))))))))))))),
  328.          (4, ''),
  329.          (0, ''))
  330.         self.check_bad_tree(tree, "a,,c")
  331.  
  332.     def test_illegal_operator(self):
  333.         # Illegal input: a $= b
  334.         tree = \
  335.         (257,
  336.          (264,
  337.           (265,
  338.            (266,
  339.             (267,
  340.              (312,
  341.               (291,
  342.                (292,
  343.                 (293,
  344.                  (294,
  345.                   (296,
  346.                    (297,
  347.                     (298,
  348.                      (299,
  349.                       (300, (301, (302, (303, (304, (1, 'a'))))))))))))))),
  350.              (268, (37, '$=')),
  351.              (312,
  352.               (291,
  353.                (292,
  354.                 (293,
  355.                  (294,
  356.                   (296,
  357.                    (297,
  358.                     (298,
  359.                      (299,
  360.                       (300, (301, (302, (303, (304, (1, 'b'))))))))))))))))),
  361.            (4, ''))),
  362.          (0, ''))
  363.         self.check_bad_tree(tree, "a $= b")
  364.  
  365.     def test_malformed_global(self):
  366.         #doesn't have global keyword in ast
  367.         tree = (257,
  368.                 (264,
  369.                  (265,
  370.                   (266,
  371.                    (282, (1, 'foo'))), (4, ''))),
  372.                 (4, ''),
  373.                 (0, ''))
  374.         self.check_bad_tree(tree, "malformed global ast")
  375.  
  376. def test_main():
  377.     test_support.run_unittest(
  378.         RoundtripLegalSyntaxTestCase,
  379.         IllegalSyntaxTestCase
  380.     )
  381.  
  382.  
  383. if __name__ == "__main__":
  384.     test_main()
  385.